#include <iostream>
#include <string>
#include <unordered_map>
using namespace std;

const int N = 20010; //会出现的数的个数
const int mod = 2;   //这个貌似可以直接用异或运算^作模二加法

unordered_map<int, int> m; //用于离散化
int idx = 0;               //用来分配空间
int p[N], d[N];            //并查集
int T, n;
int k;     //用来存储遍历到了第几个
int a, b;  //获取数据
string op; //获取指令

int find(int x)
{
    if (x == p[x])
        return x;
    int root = find(p[x]); //寻找根结点
    d[x] ^= d[p[x]];       //维护距离
    p[x] = root;           //路径压缩
    return p[x];
}

int main()
{
    freopen("cin.txt", "r", stdin);
    cin >> n >> T;
    for (int i = 1; i <= N; ++i)
        p[i] = i; //初始化并查集
    for (k = 0; k < T; ++k)
    {
        cin >> a >> b >> op;
        if (!m.count(a - 1)) //如果之前a没分配替身
        {
            m[a - 1] = idx; //那么就给他分配一个
            a = idx++;      //并且将a转到给他分配的那个
        }                   //a这里之所以要-1，是因为前缀和的原因
        else
            a = m[a - 1]; //否则就直接老马甲套起来
        if (!m.count(b))  //类比a
        {
            m[b] = idx;
            b = idx++;
        }
        else
            b = m[b];
        if (op[0] == 'e') //偶数个1
        {
            int pa = find(a), pb = find(b);
            if (pa == pb) //如果早有联系，既可以计算出关系
            {
                if (d[a] ^ d[b]) //如果这里等于1，就是一个和根结点同一类，一个不同，那么就矛盾了
                    break;       //此时直接无了
            }
            else //没联系现在就创造联系嘛
            {
                d[pa] = d[a] ^ d[b]; //这个公式又如下
                /*
                    我们现在想要的是
                    d[x]^d[pa]==d[y]
                    d[x]^d[x]^d[pa]==d[x]^d[y]
                    因为0^x==x
                    所以d[pa]==d[x]^d[y]
                    */
                p[pa] = pb; //之后就认了嘛
            }
        }
        else //奇数个1
        {
            int pa = find(a), pb = find(b);
            if (pa == pb)
            {
                if (d[a] ^ d[b] ^ 1) //如果这里等于1，那就是d[a]^d[b]==0为同一类，矛盾
                    break;
            }
            else
            {
                d[pa] = d[a] ^ d[b] ^ 1; //我们此时所以希望的是d[a]^d[pa]=d[y]^1，这里异或1的原因是x^1=!x，代表两边不等
                p[pa] = pb;              //之后就认了嘛
            }
        }
    }
    cout << k;
    return 0;
}